﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text.RegularExpressions;
using System.Web;

namespace Raspare
{
    public partial class Karaktär
    {
        private string allText;

        public const string EndLine = @"((<br>\s)|(<br\s*/>\s)|(\s\s))";

        public Karaktär(string namn, string textFromWiki)
        {
            Namn = namn;
            allText = textFromWiki;
            Fördelar = new List<string>();
            Färdigheter = new List<Färdighet>();
            Kategorier = new List<string>();
            Krokar = new List<string>();
            GetKategori();

            if (Kategorier.Contains("Incidentkommissionen"))
            {
                GetIkFärdigheter();
                GetIkFördelar();
                //GetIkUppgifter();
                GetIkPoäng();
                GetKrokar();
            }
            else
            {
                GetFärdigheter();
                GetIkFördelar();
                //GetIkUppgifter();
                GetIkPoäng();
                GetKrokar();
            }

            Färdigheter = Färdigheter.OrderBy(färdighet => färdighet.Namn).ToList();

        }

        private void GetKategori()
        {
            var regex = new Regex(@"\[\[(Category|Kategori):(?<Category>[^\].]*)\]\]", RegexOptions.Singleline);
            if (regex.IsMatch(allText))
            {
                var matches = regex.Matches(allText);
                foreach (Match match in matches)
                {
                    Kategorier.Add(match.Groups["Category"].ToString());
                }
            }
        }

        private void GetKrokar()
        {
            var regex = new Regex(@"([']{3}|[=]{3})Krok[^'^=]*([']{3}|[=]{3})\s(?<Krok>[^=^']*)", RegexOptions.Singleline);
            if (regex.IsMatch(allText))
            {
                var matches = regex.Matches(allText);
                foreach (Match match in matches)
                {

                    var allKrokar = match.Groups["Krok"].ToString();
                    if (allKrokar.Contains("*"))
                    {
                        var allStarKrokar = allKrokar.Split(new[] {'*'}, StringSplitOptions.RemoveEmptyEntries).Select(s => s.Replace("\n", "").Trim());
                        Krokar.AddRange(allStarKrokar);
                    }
                    else if(allKrokar.Contains(","))
                    {
                        var allKommaKrokar = allKrokar.Split(new[] {','}, StringSplitOptions.RemoveEmptyEntries).Select(s => s.Replace("\n", "").Trim());
                        Krokar.AddRange(allKommaKrokar);
                    }
                    else if (allKrokar.Contains("<br"))
                    {
                        var allKommaKrokar = allKrokar.Split(new[] { "<br>", "<br/>" }, StringSplitOptions.RemoveEmptyEntries).Select(s => s.Replace("\n", "").Trim());
                        Krokar.AddRange(allKommaKrokar);
                    }
                }
            }

            //GetKategori(allText);
        }

        #region IK

        private void GetFärdigheter()
        {
            //wikitable 
            var regex = new Regex(@"===Färdigheter[^=.]*===\s(?<Abilities>.*)\s\s", RegexOptions.Singleline);
            if (regex.IsMatch(allText))
            {
                var match = regex.Match(allText);

                var abilities = match.Groups["Abilities"].ToString();

                regex = new Regex(@".*wikitable.*");

                if (regex.IsMatch(abilities))
                {
                    GetJonasFärdigheter(abilities);
                }
                else
                {
                    GetIkFärdigheter();
                }
            }
        }

        private void GetJonasFärdigheter(string abilities)
        {
            var regex = new Regex(@"(?<row>.*)\|-", RegexOptions.Singleline);

            var matches = regex.Matches(abilities);

            var splits = abilities.Replace("|}", "").Split(new [] {"|-"}, StringSplitOptions.RemoveEmptyEntries);

            //foreach (Match abilityrow in matches)
            foreach (var row in splits)
            {
                //string row = abilityrow.Groups["row"].ToString();
                if (row.Contains("wikitable")) continue;

                string[] stringSeparators = new string[] { "|" };

                var instances = row.Split(stringSeparators, StringSplitOptions.RemoveEmptyEntries);

                List<string> realList = new List<string>();

                foreach (string inst in instances)
                {
                    if (inst.Contains("style"))
                    {
                        continue;
                    }
                    string save = inst.Replace("|-", "").Replace("|", "").Replace("\n", "").Trim();
                    if(!String.IsNullOrWhiteSpace(save)) realList.Add(save);
                }

                var färdighet = new Färdighet();
                for (int i = 0; i < realList.Count; ++i)
                {
                    if (i%2 == 0)
                    {
                        färdighet = new Färdighet()
                        {
                            Specialiseringar = new List<string>()
                        };

                        string fullNamestring = realList[i];
                        if (fullNamestring.Contains("<br"))
                        {
                            var regex2 = new Regex(@"''(?<speclista>(.)*)''");
                            var specar = regex2.Match(fullNamestring).Groups["speclista"].ToString();
                            var speclista = specar.Split(',').Select(s => s.Trim()).ToList();
                            färdighet.Namn = fullNamestring.Substring(0, fullNamestring.IndexOf("<br", StringComparison.InvariantCultureIgnoreCase)).Trim();
                            färdighet.Specialiseringar = speclista;
                        }
                        else
                        {
                            färdighet.Namn = fullNamestring;
                        }
                    }
                    else
                    {
                        int value = 0;
                        Int32.TryParse(realList[i], out value);
                        färdighet.Värde = value;
                        Färdigheter.Add(färdighet);
                    }
                }
            }
        }

        private void GetIkFärdigheter()
        {
            var regex = new Regex(@"===Färdigheter[^=.]*===\s(?<Abilities>.*)\s\s", RegexOptions.Singleline);

            if (regex.IsMatch(allText))
            {
                var match = regex.Match(allText);

                var abilities = match.Groups["Abilities"].ToString();
                // (?<Name>[^,^\d.]*) (?<Value>\d+)(( \((?<Specialities>[^\).]*)\))|([^,.]*))(,|$)
                regex = new Regex(@"(?<Name>[^,^\d.]*) (?<Value>\d+)(( \((?<Specialities>[^\).]*)\))|([^,.]*))(,|$)", RegexOptions.Singleline);

                var matches = regex.Matches(abilities);

                foreach (Match ability in matches)
                {

                    var färdighet = new Färdighet()
                    {
                        Namn = ability.Groups["Name"].ToString(),
                        Värde = Int32.Parse(ability.Groups["Value"].ToString()),
                        Specialiseringar = new List<string>()
                    };

                    if (ability.Groups["Specialities"] != null && !String.IsNullOrWhiteSpace(ability.Groups["Specialities"].ToString()))
                    {

                        var specialities = ability.Groups["Specialities"].ToString().Replace("(", "").Replace(")", "").Split(',');
                        foreach (var speciality in specialities)
                        {
                            färdighet.Specialiseringar.Add(speciality.Trim());
                        }
                    }

                    Färdigheter.Add(färdighet);
                }

            }
        }
        
        private void GetIkFördelar()
        {
            var regex = new Regex(@"'''Fördelar:'''\s(?<Advantages>[^<.]*)" + EndLine, RegexOptions.Singleline);

            if (regex.IsMatch(allText))
            {
                var matches = regex.Match(allText);

                var advantages = matches.Groups["Advantages"].ToString();

                var splitAdvantages = advantages.Split(',');

                Fördelar.AddRange(splitAdvantages.Select(adv => adv.Trim()));
            }
        }

        private void GetIkPoäng()
        {
            var regex = new Regex(@"'''Veteranpoäng:'''\s*(?<Point>\d+)\s*/\s*(?<CountAdventures>[^/^<.]*)" + EndLine, RegexOptions.Singleline);

            if (regex.IsMatch(allText))
            {
                var match = regex.Match(allText);
                try
                {
                    AntalÄventyr = Int32.Parse(match.Groups["CountAdventures"].ToString().Trim());
                    Veteranpoäng = Int32.Parse(match.Groups["Point"].ToString().Trim());
                }
                catch
                {
                }
            }
            else
            {
                regex = new Regex(@"'''Veteranpoäng:'''\s*(?<Point>\d+)" + EndLine, RegexOptions.Singleline);
                if (regex.IsMatch(allText))
                {
                    var match = regex.Match(allText);
                    try
                    {
                        Veteranpoäng = Int32.Parse(match.Groups["Point"].ToString().Trim());
                    }
                    catch
                    {
                    }
                }
            }

            regex = new Regex(@"'''Rollpoäng:'''\s*(?<Point>\d+)" + EndLine, RegexOptions.Singleline);

            if (regex.IsMatch(allText))
            {
                var match = regex.Match(allText);
                try
                {
                    Rollpoäng = Int32.Parse(match.Groups["Point"].ToString().Trim());
                }catch {}
            }

            regex = new Regex(@"'''Karma:'''\s*(?<Charma>\d+)" + EndLine, RegexOptions.Singleline);

            if (regex.IsMatch(allText))
            {
                var match = regex.Match(allText);
                try
                {
                    Karma = Int32.Parse(match.Groups["Charma"].ToString().Trim());
                }
                catch { }
            }

        }

        #endregion
    }
}